/**
 * 数据管理工具
 * 统一管理设备和编组的操作，减少代码冗余
 */

const storageService = require('../services/storage')
const { logger } = require('./logger')

/**
 * 数据管理工具类
 * 提供统一的API来操作设备和编组数据
 */
const DataManager = {
  /**
   * 获取设备列表
   * @returns {Array} 设备列表
   */
  getDevices() {
    return storageService.getDevices()
  },

  /**
   * 保存设备列表
   * @param {Array} devices - 设备列表
   * @returns {boolean} 是否保存成功
   */
  saveDevices(devices) {
    return storageService.saveDevices(devices)
  },

  /**
   * 获取设备详情
   * @param {string} deviceId - 设备ID
   * @returns {Object|null} 设备对象或null
   */
  getDeviceById(deviceId) {
    const devices = this.getDevices()
    return devices.find(device => device.id === deviceId) || null
  },

  /**
   * 添加设备
   * @param {Object} device - 设备对象
   * @returns {boolean} 是否添加成功
   */
  addDevice(device) {
    if (!device || !device.id) {
      logger.error('添加设备失败: 无效的设备对象', device)
      return false
    }

    const devices = this.getDevices()
    // 检查设备是否已存在
    const existingIndex = devices.findIndex(d => d.id === device.id)
    if (existingIndex >= 0) {
      logger.warn(`设备已存在，ID: ${device.id}`)
      return false
    }

    devices.push(device)
    return this.saveDevices(devices)
  },

  /**
   * 更新设备
   * @param {Object} device - 设备对象
   * @returns {boolean} 是否更新成功
   */
  updateDevice(device) {
    if (!device || !device.id) {
      logger.error('更新设备失败: 无效的设备对象', device)
      return false
    }

    const devices = this.getDevices()
    const index = devices.findIndex(d => d.id === device.id)
    if (index < 0) {
      logger.warn(`更新设备失败: 设备不存在，ID: ${device.id}`)
      return false
    }

    devices[index] = { ...devices[index], ...device }
    return this.saveDevices(devices)
  },

  /**
   * 删除设备
   * @param {string} deviceId - 设备ID
   * @returns {boolean} 是否删除成功
   */
  removeDevice(deviceId) {
    if (!deviceId) {
      logger.error('删除设备失败: 无效的设备ID')
      return false
    }

    const devices = this.getDevices()
    const index = devices.findIndex(d => d.id === deviceId)
    if (index < 0) {
      logger.warn(`删除设备失败: 设备不存在，ID: ${deviceId}`)
      return false
    }

    // 删除设备
    devices.splice(index, 1)

    // 保存更新后的设备列表
    const saveResult = this.saveDevices(devices)

    // 删除设备相关的所有配置
    storageService.clearDeviceData(deviceId, false)

    return saveResult
  },

  /**
   * 获取编组列表
   * @returns {Array} 编组列表
   */
  getGroups() {
    return storageService.getGroups()
  },

  /**
   * 保存编组列表
   * @param {Array} groups - 编组列表
   * @returns {boolean} 是否保存成功
   */
  saveGroups(groups) {
    return storageService.saveGroups(groups)
  },

  /**
   * 获取编组详情
   * @param {string} groupId - 编组ID
   * @returns {Object|null} 编组对象或null
   */
  getGroupById(groupId) {
    const groups = this.getGroups()
    return groups.find(group => group.id === groupId) || null
  },

  /**
   * 添加编组
   * @param {Object} group - 编组对象
   * @returns {boolean} 是否添加成功
   */
  addGroup(group) {
    if (!group || !group.id) {
      logger.error('添加编组失败: 无效的编组对象', group)
      return false
    }

    const groups = this.getGroups()
    // 检查编组是否已存在
    const existingIndex = groups.findIndex(g => g.id === group.id)
    if (existingIndex >= 0) {
      logger.warn(`编组已存在，ID: ${group.id}`)
      return false
    }

    groups.push(group)
    return this.saveGroups(groups)
  },

  /**
   * 更新编组
   * @param {Object} group - 编组对象
   * @returns {boolean} 是否更新成功
   */
  updateGroup(group) {
    if (!group || !group.id) {
      logger.error('更新编组失败: 无效的编组对象', group)
      return false
    }

    const groups = this.getGroups()
    const index = groups.findIndex(g => g.id === group.id)
    if (index < 0) {
      logger.warn(`更新编组失败: 编组不存在，ID: ${group.id}`)
      return false
    }

    groups[index] = { ...groups[index], ...group }
    return this.saveGroups(groups)
  },

  /**
   * 删除编组
   * @param {string} groupId - 编组ID
   * @returns {boolean} 是否删除成功
   */
  removeGroup(groupId) {
    if (!groupId) {
      logger.error('删除编组失败: 无效的编组ID')
      return false
    }

    const groups = this.getGroups()
    const index = groups.findIndex(g => g.id === groupId)
    if (index < 0) {
      logger.warn(`删除编组失败: 编组不存在，ID: ${groupId}`)
      return false
    }

    // 删除编组
    groups.splice(index, 1)

    // 保存更新后的编组列表
    const saveResult = this.saveGroups(groups)

    // 删除编组相关的所有配置
    storageService.clearGroupData(groupId)

    return saveResult
  },

  /**
   * 获取设备或编组的模式设置数据
   * @param {string} id - 设备ID或编组ID
   * @param {boolean} isGroup - 是否为编组
   * @param {string} deviceType - 设备类型
   * @returns {Object} 模式设置数据
   */
  getModeSettingData(id, isGroup = false, deviceType) {
    return storageService.getModeSettingData(id, isGroup, deviceType)
  },

  /**
   * 保存设备或编组的模式设置数据
   * @param {string} id - 设备ID或编组ID
   * @param {Object} data - 模式设置数据
   * @param {boolean} isGroup - 是否为编组
   * @param {string} deviceType - 设备类型
   * @returns {boolean} 是否保存成功
   */
  saveModeSettingData(id, data, isGroup = false, deviceType) {
    return storageService.saveModeSettingData(id, data, isGroup, deviceType)
  },

  /**
   * 获取设备或编组的快捷模式数据
   * @param {string} id - 设备ID或编组ID
   * @param {boolean} isGroup - 是否为编组
   * @param {string} deviceType - 设备类型
   * @returns {Object} 快捷模式数据
   */
  getShortcutModeData(id, isGroup = false, deviceType) {
    return storageService.getShortcutModeData(id, isGroup, deviceType)
  },

  /**
   * 保存设备或编组的快捷模式数据
   * @param {string} id - 设备ID或编组ID
   * @param {Object} data - 快捷模式数据
   * @param {boolean} isGroup - 是否为编组
   * @param {string} deviceType - 设备类型
   * @returns {boolean} 是否保存成功
   */
  saveShortcutModeData(id, data, isGroup = false, deviceType) {
    return storageService.saveShortcutModeData(id, data, isGroup, deviceType)
  },

  /**
   * 获取设备或编组的玩家模式数据
   * @param {string} id - 设备ID或编组ID
   * @param {boolean} isGroup - 是否为编组
   * @param {string} deviceType - 设备类型
   * @returns {Object} 玩家模式数据
   */
  getPlayerModeData(id, isGroup = false, deviceType) {
    return storageService.getPlayerModeData(id, isGroup, deviceType)
  },

  /**
   * 保存设备或编组的玩家模式数据
   * @param {string} id - 设备ID或编组ID
   * @param {Object} data - 玩家模式数据
   * @param {boolean} isGroup - 是否为编组
   * @param {string} deviceType - 设备类型
   * @returns {boolean} 是否保存成功
   */
  savePlayerModeData(id, data, isGroup = false, deviceType) {
    return storageService.savePlayerModeData(id, data, isGroup, deviceType)
  },

  /**
   * 获取设备或编组的高阶模式数据
   * @param {string} id - 设备ID或编组ID
   * @param {boolean} isGroup - 是否为编组
   * @param {string} deviceType - 设备类型
   * @returns {Object} 高阶模式数据
   */
  getAdvancedModeData(id, isGroup = false, deviceType) {
    return storageService.getAdvancedModeData(id, isGroup, deviceType)
  },

  /**
   * 保存设备或编组的高阶模式数据
   * @param {string} id - 设备ID或编组ID
   * @param {Object} data - 高阶模式数据
   * @param {boolean} isGroup - 是否为编组
   * @param {string} deviceType - 设备类型
   * @returns {boolean} 是否保存成功
   */
  saveAdvancedModeData(id, data, isGroup = false, deviceType) {
    return storageService.saveAdvancedModeData(id, data, isGroup, deviceType)
  },

  /**
   * 获取灯光模式状态（自动/手动）
   * @param {string} id - 设备ID或编组ID
   * @param {boolean} isGroup - 是否为编组
   * @param {string} deviceType - 设备类型
   * @returns {string} 灯光模式状态
   */
  getLightModeState(id, isGroup = false, deviceType) {
    return storageService.getLightModeState(id)
  },

  /**
   * 保存灯光模式状态（自动/手动）
   * @param {string} id - 设备ID或编组ID
   * @param {string} state - 灯光模式状态
   * @param {boolean} isGroup - 是否为编组
   * @param {string} deviceType - 设备类型
   * @returns {boolean} 是否保存成功
   */
  saveLightModeState(id, state, isGroup = false, deviceType) {
    return storageService.saveLightModeState(id, state, isGroup, deviceType)
  },
}

module.exports = DataManager
